// index.js
const app = getApp()

Page({
  data: {
    categoryList: [], // 分类列表
    dishList: [], // 菜品列表
    setmealList: [], // 套餐列表
    cartList: [], // 购物车列表
    currentCategory: {}, // 当前选中的分类
    totalPrice: 0, // 总价
    totalCount: 0, // 总数量
    deliveryFee: 5, // 配送费
    minDeliveryAmount: 20, // 最低配送金额
    showCartPopup: false, // 是否显示购物车弹窗
    shopStatus: 0, // 店铺状态：0-打烊，1-营业中
    loading: true, // 加载状态
    showFlavorPopup: false, // 是否显示口味选择弹窗
    currentDish: null, // 当前选择的菜品
    selectedFlavors: {}, // 已选择的口味
    showDishDetail: false, // 是否显示菜品详情弹窗
  },

  onLoad() {
    this.checkLogin()
  },

  onShow() {
    // 每次显示页面时获取最新的购物车数据
    this.getShopCartList()
  },

  // 检查登录状态
  async checkLogin() {
    const token = wx.getStorageSync('authentication')
    if (!token) {
      await this.login()
    } else {
      // 获取店铺状态
      await this.getShopStatus()
      // 加载其他数据
      this.loadData()
    }
  },

  // 获取店铺状态
  async getShopStatus() {
    try {
      const res = await this.request('/user/shop/status')
      if (res.code === 1) {
        this.setData({
          shopStatus: res.data
        })
        
        // 如果店铺已打烊，显示提示
        if (res.data === 0) {
          wx.showToast({
            title: '店铺已打烊',
            icon: 'none',
            duration: 2000
          })
        }
      }
    } catch (error) {
      console.error('获取店铺状态失败：', error)
    }
  },

  // 获取购物车列表
  async getShopCartList() {
    try {
      const res = await this.request('/user/shoppingCart/list')
      if (res.code === 1) {
        const cartList = res.data || []
        let totalPrice = 0
        let totalCount = 0
        
        // 计算总价和总数量
        cartList.forEach(item => {
          totalPrice += item.amount * item.number
          totalCount += item.number
        })
        
        this.setData({
          cartList,
          totalPrice,
          totalCount
        })
        
        // 更新菜品列表中的数量
        this.updateDishListNumber(cartList)
      }
    } catch (error) {
      console.error('获取购物车列表失败：', error)
    }
  },

  // 更新菜品列表中的数量
  updateDishListNumber(cartList) {
    const { dishList, setmealList } = this.data
    
    // 重置所有数量为0
    dishList.forEach(dish => dish.number = 0)
    setmealList.forEach(setmeal => setmeal.number = 0)
    
    // 更新数量
    cartList.forEach(cart => {
      if (cart.dishId) {
        // 更新菜品数量
        const dish = dishList.find(d => d.id === cart.dishId)
        if (dish) {
          dish.number = cart.number
        }
      } else if (cart.setmealId) {
        // 更新套餐数量
        const setmeal = setmealList.find(s => s.id === cart.setmealId)
        if (setmeal) {
          setmeal.number = cart.number
        }
      }
    })
    
    this.setData({
      dishList,
      setmealList
    })
  },

  // 加载数据
  async loadData() {
    try {
      // 获取分类列表
      const categoryRes = await this.request('/user/category/list')
      
      if (categoryRes.code === 1) {
        const categoryList = categoryRes.data
        this.setData({
          categoryList,
          currentCategory: categoryList[0]
        })
        
        // 获取第一个分类的菜品和套餐
        if (categoryList.length > 0) {
          await this.loadCategoryData(categoryList[0].id)
        }
      }
    } catch (error) {
      console.error('加载数据失败：', error)
      wx.showToast({
        title: '加载失败，请重试',
        icon: 'none'
      })
    } finally {
      this.setData({ loading: false })
    }
  },

  // 加载分类下的菜品和套餐
  async loadCategoryData(categoryId) {
    try {
      // 并行加载菜品和套餐数据
      const [dishRes, setmealRes] = await Promise.all([
        this.request(`/user/dish/list?categoryId=${categoryId}`),
        this.request(`/user/setmeal/list?categoryId=${categoryId}`)
      ])
      
      let dishList = []
      let setmealList = []
      
      // 处理菜品数据
      if (dishRes.code === 1) {
        dishList = dishRes.data.map(dish => ({
          ...dish,
          number: 0
        }))
      }
      
      // 处理套餐数据
      if (setmealRes.code === 1) {
        setmealList = setmealRes.data.map(setmeal => ({
          ...setmeal,
          number: 0
        }))
        
        // 获取套餐包含的菜品信息
        for (let setmeal of setmealList) {
          await this.loadSetmealDishes(setmeal)
        }
      }
      
      this.setData({
        dishList,
        setmealList
      })
      
      // 更新购物车中的数量
      if (this.data.cartList.length > 0) {
        this.updateDishListNumber(this.data.cartList)
      }
      
    } catch (error) {
      console.error('加载分类数据失败：', error)
      wx.showToast({
        title: '加载失败，请重试',
        icon: 'none'
      })
    }
  },

  // 获取套餐包含的菜品
  async loadSetmealDishes(setmeal) {
    try {
      const res = await this.request(`/user/setmeal/dish/${setmeal.id}`)
      if (res.code === 1) {
        setmeal.dishList = res.data
      }
    } catch (error) {
      console.error(`获取套餐${setmeal.id}菜品失败：`, error)
    }
  },

  // 切换分类
  async switchCategory(e) {
    const category = e.currentTarget.dataset.category
    this.setData({
      currentCategory: category,
      loading: true
    })
    await this.loadCategoryData(category.id)
    this.setData({ loading: false })
  },

  // 增加商品数量
  async onPlusClick(e) {
    if (this.data.shopStatus === 0) {
      wx.showToast({
        title: '店铺已打烊',
        icon: 'none'
      })
      return
    }
    
    const item = e.currentTarget.dataset.item
    const isSetmeal = e.currentTarget.dataset.type === 'setmeal'
    
    // 检查当前商品数量是否达到上限
    const currentItem = this.data.cartList.find(cart => 
      isSetmeal ? cart.setmealId === item.id : cart.dishId === item.id
    )
    
    if (currentItem && currentItem.number >= 10) {
      wx.showToast({
        title: '同一商品最多只能购买10份',
        icon: 'none'
      })
      return
    }
    
    try {
      // 添加到购物车
      const res = await this.request('/user/shoppingCart/add', 'POST', {
        dishId: isSetmeal ? null : item.id,
        setmealId: isSetmeal ? item.id : null,
        dishFlavor: '', // 口味，如果需要可以添加
        number: 1,
        amount: item.price
      })
      
      if (res.code === 1) {
        // 重新获取购物车数据
        await this.getShopCartList()
      } else {
        wx.showToast({
          title: res.msg || '添加失败',
          icon: 'none'
        })
      }
    } catch (error) {
      console.error('添加购物车失败：', error)
      wx.showToast({
        title: '添加失败，请重试',
        icon: 'none'
      })
    }
  },

  // 减少商品数量
  async onMinusClick(e) {
    const item = e.currentTarget.dataset.item
    const isSetmeal = e.currentTarget.dataset.type === 'setmeal'
    
    try {
      // 获取购物车中的商品
      const cartItem = this.data.cartList.find(cart => 
        isSetmeal ? cart.setmealId === item.id : cart.dishId === item.id
      )
      
      if (cartItem) {
        // 删除购物车中的商品
        const res = await this.request('/user/shoppingCart/sub', 'POST', {
          dishId: isSetmeal ? null : item.id,
          setmealId: isSetmeal ? item.id : null
        })
        
        if (res.code === 1) {
          // 重新获取购物车数据
          await this.getShopCartList()
        } else {
          wx.showToast({
            title: res.msg || '操作失败',
            icon: 'none'
          })
        }
      }
    } catch (error) {
      console.error('减少商品失败：', error)
      wx.showToast({
        title: '操作失败，请重试',
        icon: 'none'
      })
    }
  },

  // 清空购物车
  async clearCart() {
    try {
      const res = await this.request('/user/shoppingCart/clean', 'DELETE')
      if (res.code === 1) {
        this.setData({
          cartList: [],
          totalPrice: 0,
          totalCount: 0,
          showCartPopup: false
        })
        
        // 重置菜品和套餐数量
        const dishList = this.data.dishList.map(dish => ({...dish, number: 0}))
        const setmealList = this.data.setmealList.map(setmeal => ({...setmeal, number: 0}))
        this.setData({ dishList, setmealList })
      }
    } catch (error) {
      console.error('清空购物车失败：', error)
      wx.showToast({
        title: '清空失败，请重试',
        icon: 'none'
      })
    }
  },

  // 登录
  async login() {
    try {
      const loginRes = await wx.login()
      if (loginRes.code) {
        const res = await this.request('/user/user/login', 'POST', {
          code: loginRes.code
        }, false) // 登录请求不需要带token
        
        if (res.code === 1) {
          wx.setStorageSync('authentication', res.data.token)
          wx.setStorageSync('userInfo', res.data)
          this.loadData()
        } else {
          wx.showToast({
            title: res.msg || '登录失败',
            icon: 'none'
          })
        }
      }
    } catch (error) {
      console.error('登录失败：', error)
      wx.showToast({
        title: '登录失败，请重试',
        icon: 'none'
      })
    }
  },

  // 封装请求方法
  request(url, method = 'GET', data = {}, needToken = true) {
    const baseUrl = 'http://localhost:8080'
    const token = wx.getStorageSync('authentication')
    
    return new Promise((resolve, reject) => {
      const header = {
        'content-type': 'application/json'
      }
      
      if (needToken && token) {
        header['authentication'] = token
      }
      
      wx.request({
        url: `${baseUrl}${url}`,
        method,
        data,
        header,
        success: (res) => {
          if (res.statusCode === 401) {
            // token失效，清除token并重新登录
            wx.removeStorageSync('authentication')
            wx.removeStorageSync('userInfo')
            this.login()
            reject(new Error('未登录或登录已过期'))
          } else {
            resolve(res.data)
          }
        },
        fail: reject
      })
    })
  },

  // 去结算
  onSubmit() {
    if (this.data.totalPrice >= this.data.minDeliveryAmount) {
      // 跳转到订单确认页
      wx.navigateTo({
        url: '/pages/order/order'
      })
    }
  },

  // 拨打电话
  callShop() {
    wx.makePhoneCall({
      phoneNumber: '10086' // 这里替换为实际的店铺电话
    })
  },

  // 切换购物车弹窗显示状态
  toggleCart() {
    if (this.data.cartList.length === 0) {
      return; // 如果购物车为空，不显示弹窗
    }
    this.setData({
      showCartPopup: !this.data.showCartPopup
    });
  },

  // 在购物车弹窗中增加商品数量
  async onCartPlusClick(e) {
    const item = e.currentTarget.dataset.item
    if (item.number >= 10) {
      wx.showToast({
        title: '同一商品最多只能购买10份',
        icon: 'none'
      })
      return
    }
    
    try {
      // 添加到购物车
      const res = await this.request('/user/shoppingCart/add', 'POST', {
        dishId: item.setmealId ? null : item.dishId,
        setmealId: item.setmealId || null,
        dishFlavor: item.dishFlavor || '',
        number: 1,
        amount: item.amount
      })
      
      if (res.code === 1) {
        await this.getShopCartList()
      } else {
        wx.showToast({
          title: res.msg || '添加失败',
          icon: 'none'
        })
      }
    } catch (error) {
      console.error('添加购物车失败：', error)
      wx.showToast({
        title: '添加失败，请重试',
        icon: 'none'
      })
    }
  },

  // 在购物车弹窗中减少商品数量
  async onCartMinusClick(e) {
    const item = e.currentTarget.dataset.item
    try {
      const res = await this.request('/user/shoppingCart/sub', 'POST', {
        dishId: item.setmealId ? null : item.dishId,
        setmealId: item.setmealId || null
      })
      
      if (res.code === 1) {
        await this.getShopCartList()
      } else {
        wx.showToast({
          title: res.msg || '操作失败',
          icon: 'none'
        })
      }
    } catch (error) {
      console.error('减少商品失败：', error)
      wx.showToast({
        title: '操作失败，请重试',
        icon: 'none'
      })
    }
  },

  // 显示菜品详情
  showDishDetail(e) {
    const item = e.currentTarget.dataset.item
    this.setData({
      showDishDetail: true,
      currentDish: item
    })
  },

  // 关闭菜品详情
  closeDishDetail() {
    this.setData({
      showDishDetail: false,
      currentDish: null
    })
  },

  // 显示规格选择弹窗
  showFlavorSelect(e) {
    const item = e.currentTarget.dataset.item
    // 处理规格数据，将字符串转换为数组，并清理特殊字符
    const flavors = item.flavors.map(flavor => {
      // 如果value是字符串，按逗号分割，并清理特殊字符
      const values = typeof flavor.value === 'string' ? 
        flavor.value.split(',')
          .map(v => v.trim())
          .map(v => v.replace(/["\[\]]/g, '').trim()) : // 去除引号和方括号
        flavor.value;
      return {
        name: flavor.name,
        value: values
      }
    })
    
    this.setData({
      showFlavorPopup: true,
      currentDish: {
        ...item,
        flavors: flavors
      },
      selectedFlavors: {} // 重置已选择的口味
    })
  },

  // 选择口味
  selectFlavor(e) {
    const { flavorName, option } = e.currentTarget.dataset
    const selectedFlavors = { ...this.data.selectedFlavors }
    
    // 如果点击的是已选中的选项，则取消选中
    if (selectedFlavors[flavorName] === option) {
      delete selectedFlavors[flavorName]
    } else {
      selectedFlavors[flavorName] = option
    }
    
    this.setData({ selectedFlavors })
  },

  // 添加规格商品到购物车
  async addFlavorDishToCart() {
    const { currentDish, selectedFlavors } = this.data
    
    // 检查是否所有规格都已选择
    const allSelected = currentDish.flavors.every(flavor => 
      selectedFlavors[flavor.name]
    )
    
    if (!allSelected) {
      wx.showToast({
        title: '请选择完整规格',
        icon: 'none'
      })
      return
    }
    
    // 将选择的规格转换为字符串
    const dishFlavor = currentDish.flavors
      .map(flavor => `${flavor.name}:${selectedFlavors[flavor.name]}`)
      .join(',')
    
    try {
      const res = await this.request('/user/shoppingCart/add', 'POST', {
        dishId: currentDish.id,
        setmealId: null,
        dishFlavor,
        number: 1,
        amount: currentDish.price
      })
      
      if (res.code === 1) {
        await this.getShopCartList()
        this.closeFlavorSelect()
        // 如果是从菜品详情打开的规格选择，同时关闭菜品详情
        if (this.data.showDishDetail) {
          this.closeDishDetail()
        }
      } else {
        wx.showToast({
          title: res.msg || '添加失败',
          icon: 'none'
        })
      }
    } catch (error) {
      console.error('添加购物车失败：', error)
      wx.showToast({
        title: '添加失败，请重试',
        icon: 'none'
      })
    }
  },

  // 关闭规格选择弹窗
  closeFlavorSelect() {
    this.setData({
      showFlavorPopup: false,
      currentDish: null,
      selectedFlavors: {}
    })
  },

  // 从菜品详情中直接加入购物车
  async onDetailPlusClick(e) {
    const item = e.currentTarget.dataset.item
    const type = e.currentTarget.dataset.type
    await this.onPlusClick(e)
    this.closeDishDetail() // 添加完成后关闭详情弹窗
  },
})
